home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 4 / Info_Mac IV CD-ROM (Pacific HiTech Inc.)(August 1994).iso / Development / Source / Jotto2.so Folder / Jotto ][ ƒ / MSG Shell ƒ / msg menus.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-04  |  5.8 KB  |  272 lines  |  [TEXT/KAHL]
  1. /**********************************************************************\
  2.  
  3. File:        msg menus.c
  4.  
  5. Purpose:    This module handles menu selections, including selection
  6.             of dimmed menu items (hehe).
  7.  
  8.  
  9. Jotto ][ -=- a simple word game, revisited
  10. Copyright (C) 1993 Mark Pilgrim
  11.  
  12. This program is free software; you can redistribute it and/or modify
  13. it under the terms of the GNU General Public License as published by
  14. the Free Software Foundation; either version 2 of the License, or
  15. (at your option) any later version.
  16.  
  17. This program is distributed in the hope that it will be useful,
  18. but WITHOUT ANY WARRANTY; without even the implied warranty of
  19. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20. GNU General Public License for more details.
  21.  
  22. You should have received a copy of the GNU General Public License
  23. along with this program in a file named "GNU General Public License".
  24. If not, write to the Free Software Foundation, 675 Mass Ave,
  25. Cambridge, MA 02139, USA.
  26.  
  27. \**********************************************************************/
  28.  
  29. #include "msg graphics.h"
  30. #include "msg menus.h"
  31. #include "msg sounds.h"
  32. #include "msg prefs.h"
  33. #include "msg environment.h"
  34. #include "jotto globals.h"
  35. #include "jotto load-save.h"
  36. #include "jotto.h"
  37.  
  38. Boolean            gMenuEnabled;
  39. MenuHandle        gAppleMenu;
  40. MenuHandle        gFileMenu;
  41. MenuHandle        gEditMenu;
  42. MenuHandle        gOptionsMenu;
  43. MenuHandle        gHelpMenu;
  44.  
  45. extern    long        menuDisable : 0x0b54;
  46.  
  47. void AdjustMenus(void)
  48. {
  49.     WindowPeek    theWindow;
  50.     short            kind;
  51. //    short            i;
  52.     
  53.     theWindow = (WindowPeek)FrontWindow();
  54.     kind = theWindow ? theWindow->windowKind : 0;
  55.     
  56.     if(kind < 0)
  57.         EnableItem(gEditMenu, 0);
  58.     else
  59.         DisableItem(gEditMenu, 0);
  60.     
  61.     if(theWindow)
  62.         EnableItem(gFileMenu, closeItem);
  63.     else
  64.         DisableItem(gFileMenu, closeItem);
  65.     
  66.     EnableItem(gFileMenu, newItem);
  67.     EnableItem(gFileMenu, openItem);
  68.     EnableItem(gOptionsMenu, nonWordsToggle);
  69.     if (gMainWindow)
  70.     {
  71.         EnableItem(gFileMenu, saveItem);
  72.         EnableItem(gFileMenu, saveAsItem);
  73.         DisableItem(gOptionsMenu, dupToggle);
  74.         DisableItem(gOptionsMenu, useFiveLetter);
  75.         DisableItem(gOptionsMenu, useSixLetter);
  76.     }
  77.     else
  78.     {
  79.         DisableItem(gFileMenu, saveItem);
  80.         DisableItem(gFileMenu, saveAsItem);
  81.         EnableItem(gOptionsMenu, dupToggle);
  82.         if (gFiveLetterOK)
  83.             EnableItem(gOptionsMenu, useFiveLetter);
  84.         else
  85.             DisableItem(gOptionsMenu, useFiveLetter);
  86.         
  87.         if (gSixLetterOK)
  88.             EnableItem(gOptionsMenu, useSixLetter);
  89.         else
  90.             DisableItem(gOptionsMenu, useSixLetter);
  91.     }
  92.     
  93.     CheckItem(gOptionsMenu, dupToggle, gAllowDup);
  94.     CheckItem(gOptionsMenu, nonWordsToggle, gNonWordsCount);
  95.     CheckItem(gOptionsMenu, animationToggle, gAnimation);
  96.     CheckItem(gOptionsMenu, useFiveLetter, (gNumLetters==5));
  97.     CheckItem(gOptionsMenu, useSixLetter, (gNumLetters==6));
  98.     
  99.     CheckItem(gOptionsMenu, soundToggle, gSoundToggle&&gSoundAvailable);
  100.     if (gSoundAvailable)
  101.         EnableItem(gOptionsMenu, soundToggle);
  102.     else
  103.         DisableItem(gOptionsMenu, soundToggle);
  104.     
  105. //    DrawMenuBar();
  106. }
  107.  
  108. void HandleMenu(long mSelect)
  109. {
  110.     short            menuID = HiWord(mSelect);
  111.     short            menuItem = LoWord(mSelect);
  112.     
  113.     if (menuID==0)
  114.     {
  115.         menuID=HiWord(menuDisable);
  116.         menuItem=LoWord(menuDisable);
  117.         gMenuEnabled=FALSE;
  118.     }
  119.     else gMenuEnabled=TRUE;
  120.     menuDisable=0L;
  121.  
  122.     switch (menuID)
  123.     {
  124.         case appleMenu:
  125.             HandleAppleMenu(menuItem);
  126.             break;
  127.         case fileMenu:
  128.             HandleFileMenu(menuItem);
  129.             break;    
  130.         case editMenu:
  131.             HandleEditMenu(menuItem);
  132.             break;
  133.         case optionsMenu:
  134.             HandleOptionsMenu(menuItem);
  135.             break;
  136.         case helpMenu:
  137.             HandleHelpMenu(menuItem);
  138.             break;
  139.       }
  140. }
  141.  
  142. void HandleAppleMenu(short menuItem)
  143. {
  144.     GrafPtr        savePort;
  145.     Str255        name;
  146.     
  147.     if(menuItem == 1)
  148.         ShowInformation();
  149.     if (menuItem == 2)
  150.         ShowSplashScreen();
  151.     else if(menuItem > 3)
  152.     {
  153.         GetPort(&savePort);
  154.         GetItem(gAppleMenu, menuItem, name);
  155.         OpenDeskAcc(name);
  156.         SetPort(savePort);
  157.     }
  158. }
  159.  
  160. void HandleFileMenu(short menuItem)
  161. {
  162. //    Point            where;
  163. //    SFTypeList        typeList;
  164. //    SFReply            reply;
  165.     WindowPtr        theWindow;
  166.     short                i;
  167.     
  168.     switch (menuItem)
  169.     {
  170.         case newItem:
  171.             if (gMenuEnabled)
  172.             {
  173.                 if(gMainWindow)
  174.                     CloseMainWindow();
  175.                 
  176.                 NewGame();
  177.                 AdjustMenus();
  178.             }
  179.             else DoSound(sound_fluff);
  180.             break;
  181.         case openItem:
  182.             if (gMenuEnabled)
  183.             {
  184.                 if(gMainWindow)
  185.                     CloseMainWindow();
  186.                 
  187.                 LoadSaveDispatch(TRUE, FALSE);
  188.                 AdjustMenus();
  189.             }
  190.             else DoSound(sound_fluff);
  191.             break;
  192.         case closeItem:
  193.             if (gMenuEnabled)
  194.             {
  195.                 theWindow=FrontWindow();
  196.                 for (i=0; i<NUM_HELP; i++)
  197.                     if (theWindow == gHelp[i])
  198.                         gHelp[i]=0L;
  199.                 
  200.                 if(theWindow == gMainWindow)
  201.                     CloseMainWindow();
  202.                 else
  203.                     DisposeWindow(theWindow);
  204.                 
  205.                 AdjustMenus();
  206.             }
  207.             else DoSound(sound_fluff);
  208.             break;
  209.         case saveItem:
  210.             if (gMenuEnabled)
  211.                 LoadSaveDispatch(FALSE, TRUE);
  212.             else DoSound(sound_fluff);
  213.             break;
  214.         case saveAsItem:
  215.             if (gMenuEnabled)
  216.                 LoadSaveDispatch(FALSE, FALSE);
  217.             else DoSound(sound_fluff);
  218.             break;
  219.         case quitItem:
  220.             gDone = TRUE;
  221.             break;
  222.     }
  223. }
  224.  
  225. void HandleEditMenu(short menuItem)
  226. {
  227.     if ((menuItem>0) && (menuItem!=2))
  228.         if (gMenuEnabled)
  229.         {
  230.             if(!SystemEdit(menuItem - 1))
  231.                 if(menuItem == undoItem)
  232.                     GameUndo();
  233.         }
  234.         else DoSound(sound_fluff);
  235. }
  236.  
  237. void HandleOptionsMenu(short menuItem)
  238. {
  239.     switch (menuItem)
  240.     {
  241.         case dupToggle:
  242.         case nonWordsToggle:
  243.         case useFiveLetter:
  244.         case useSixLetter:
  245.         case animationToggle:
  246.         case soundToggle:
  247.             if (gMenuEnabled)
  248.             {
  249.                 switch (menuItem)
  250.                 {
  251.                     case dupToggle:            gAllowDup=!gAllowDup; break;
  252.                     case nonWordsToggle:    gNonWordsCount=!gNonWordsCount; break;
  253.                     case useFiveLetter:        gNumLetters=0x05; break;
  254.                     case useSixLetter:        gNumLetters=0x06; break;
  255.                     case animationToggle:    gAnimation=!gAnimation; break;
  256.                     case soundToggle:        gSoundToggle=!gSoundToggle; DoSound(sound_on); break;
  257.                 }
  258.                 SaveThePrefs();
  259.             }
  260.             else DoSound(sound_fluff);
  261.     }
  262. }
  263.  
  264. void HandleHelpMenu(short menuItem)
  265. {
  266.     if ((menuItem>0) && (menuItem<=NUM_HELP))
  267.     {
  268.         OpenHelpWindow(menuItem-1);
  269.         SelectWindow(gHelp[menuItem-1]);
  270.     }
  271. }
  272.